package 方法句柄;

/*●概述
众所周知，Java从最初发布时就支持反射，通过反射可以在运行时获取类型信息，但其有个缺点就是执行速度较慢。于是从Java 7开始提供了另一套API MethodHandle 。其与反射
的作用类似，可以在运行时访问类型信息，但是据说其执行效率比反射更高，也被称为Java的 现代化反射。

官方对其定义如下：

A method handle is a typed, directly executable reference to an underlying method, constructor, field, or similar low-level 
operation, with optional transformations of arguments or return values.
‎方法句柄是对基础方法、构造函数、字段或类似的低级操作的类型化、直接可执行引用，具有参数或返回值的可选转换。‎


在《深入理解Java虚拟机》第三版中，作者也提到了MethodHandle, 但作者更多是从JVM的层面理解它，认为其主要目的是为JVM设计的一套API，以支持其他JVM语言的反射能力，
例如Groovy 、Scale、Kotlin 等。

本文主要从Java编程语言的角度来看一下如何使用这套API，至于其运行效率是不是真的比反射高，以及高多少都不会涉及，有兴趣的可以自行研究。

●关键概念
◾Lookup：MethodHandle 的创建工厂，通过它可以创建MethodHandle，值得注意的是检查工作是在创建时处理的，而不是在调用时处理。

◾MethodType：顾名思义，就是代表方法的签名。一个方法的返回值类型是什么，有几个参数，每个参数的类型什么？

◾MethodHandle：方法句柄，通过它我们就可以动态访问类型信息了。
 方法句柄是对底层方法、构造函数、字段或类似低级操作的类型化、直接可执行的引用，具有参数或返回值的可选转换。这些转换非常普遍，包括转换、插入、删除和替换等模式 
    1.句柄（Handle）来标示应用程序中不同的对象和同类中不同的实例
    2.注意：句柄有人认为是指针、或者引用
    区分什么是指针/引用/句柄
     1.指针是对象在内存中的地址;
     2.引用是对象的别名，其实质就是功能受限但是安全性更高的指针；
     3.句柄是指针的指针，句柄实际上是一个数据，是一个Long (整长型)的数据。句柄是一个标识符，是拿来标识对象或者项目的。

●如何使用
当理解了上面几个关键概念后使用起来就比较简单了，总的来说只需要4步：

1.创建Lookup
2.创建MethodType
3.基于Lookup与MethodType获得MethodHandle
4.调用MethodHandle
那我们接下来就按照上面4个步骤通过方法句柄来访问一下某个类里面的方法以及属性等。

首先提供一个目标类:
*/
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
//public class HandleTarget {
class HandleTarget {
    private String name = "hello world";
    public String name1="not private";
    public HandleTarget() {
    }

    public HandleTarget(String name) {
        this.name = name;
    }

    public void connectName(String name) {
        this.name = this.name + " " + name;
    }

    public String getName() {
        return name;
    }

    private void learnPrograming(String lang) {
        System.out.println(String.format("I am learning %s ", lang));
    }

    public static String declaration(String author) {
        return author + ": " + "吾生也有涯，而知也无涯。以有涯随无涯，殆己";
    }

    @Override
    public String toString() {
        return "HandleTarget{" +
                "name='" + name + '\'' +
                '}';
    }
}
public class 方法句柄1{
	public static void main(String[] args) throws Throwable {
		//1.创建Lookup
		MethodHandles.Lookup lookup = MethodHandles.lookup();
		System.out.println("MethodHandles.Lookup:"+lookup.toString());//方法句柄.方法句柄1
		
		//访问无参数构造器:
		//2.创建MethodType  使用其(MethodType)静态方法创建:
		MethodType con1Mt = MethodType.methodType(void.class);//方法类型：返回：void,输入参数：无。描述符：()void
		//3.1创建构造函数MethodHandle:  public MethodHandle findConstructor(Class<?> refc, MethodType type)
		MethodHandle con1Mh = lookup.findConstructor(HandleTarget.class, con1Mt);//搜索类：HandleTarget.class，无参数构造器
		//4.调用MethodHandle 使用MethodHandle的invoke家族方法
		//public final native @PolymorphicSignature Object invoke(Object... args) throws Throwable;
		Object target1 = con1Mh.invoke();//获得所搜索的无参数构造器类的实例
		System.out.println("MethodType:"+con1Mt.toString());//()void 无返回方法、无参数的描述符
		System.out.println("MethodHandle:"+con1Mh.toString());//MethodHandle()HandleTarget
		System.out.println(target1.toString());//HandleTarget{name='hello world'}
		
		//有参数构造器
		MethodType con2Mt = MethodType.methodType(void.class, String.class);//方法类型：返回类型：void,输入参数：String.class。描述符：(String)void
		MethodHandle con2Mh = lookup.findConstructor(HandleTarget.class, con2Mt);//搜索类：HandleTarget.class，有参数(1个String参数)构造器
		Object target2 = con2Mh.invoke("ErGouWang");//获得所搜索的有参数构造器类的实例
		System.out.println(con2Mt.toString());//(String)void
		System.out.println(con2Mh.toString());//MethodHandle(String)HandleTarget
		System.out.println(target2.toString());//HandleTarget{name='ErGouWang'}
		
		//调用非private实例方法
		////2.创建MethodType  使用其(MethodType)静态方法创建:
		MethodType getterMt = MethodType.methodType(String.class);//方法类型：返回：String，输入参数：无
		//3.2创建实例方法MethodHandle   public MethodHandle findVirtual(Class<?> refc, String name, MethodType type)
		//获得方法类型为getterMt(方法类型：返回：String，输入参数：无)的getName方法实例：
		MethodHandle getterMh = lookup.findVirtual(HandleTarget.class, "getName", getterMt);
		String name = (String) getterMh.invoke(target2);//使用有参数构造器
		System.out.println(name);//ErGouWang
		System.out.println(getterMt.toString());//()String
		System.out.println(getterMh.toString());//MethodHandle(HandleTarget)String
		
		//访问private方法
		//Method getDeclaredMethod(name, Class...)：获取当前类的某个Method（不包括父类）:
		//如：获取private方法getGrade，参数为int:
        //System.out.println(stdClass.getDeclaredMethod("getGrade", int.class));
		//获取HandleTarget.class类实例的private方法learnPrograming，参数为String
		Method learnMethod = HandleTarget.class.getDeclaredMethod("learnPrograming", String.class);
		learnMethod.setAccessible(true);//为了调用非public方法，我们通过Method.setAccessible(true)允许其调用
		MethodHandle learnProMh = lookup.unreflect(learnMethod);
		learnProMh.invoke(target1, "Java");//I am learning Java
		System.out.println(learnProMh.toString());//MethodHandle(HandleTarget,String)void
		learnMethod.invoke(target1, "Java");//I am learning Java
		
		//调用静态方法
		MethodType decMt = MethodType.methodType(String.class, String.class);
		//3.3创建类方法的MethodHandle   public MethodHandle findStatic(Class<?> refc, String name, MethodType type)
		MethodHandle decMh = lookup.findStatic(HandleTarget.class, "declaration", decMt);
		String dec = (String) decMh.invoke("庄子");
		System.out.println(dec);
		
		//访问非private属性
		//3.4创建非private的Field的访问MethodHandle. public MethodHandle findGetter(Class<?> refc, String name, Class<?> type)
		//注意这个不是获取field的javabean Setter方法，与其毫无关系。通过这个setter 方法句柄我们就可以访问到这个属性了。
		MethodHandle nameMh= lookup.findGetter(HandleTarget.class,"name1", String.class);
		System.out.println("adsasdasda"+(String) nameMh.invoke(con1Mh.invoke()));//not private
		//对应的如果要设置此属性的值，使用Setter方法句柄
		//public MethodHandle findSetter(Class<?> refc, String name, Class<?> type)
		MethodHandle nameMhs= lookup.findSetter(HandleTarget.class,"name1", String.class);
//		System.out.println(nameMhs.toString());
//		System.out.println(nameMhs.invoke("abcd"));//not private
		
		//访问private的属性，需要借助反射
		Field nameField = HandleTarget.class.getDeclaredField("name");
		nameField.setAccessible(true);
		MethodHandle nameFromRefMh = lookup.unreflectGetter(nameField);
		System.out.println((String) nameFromRefMh.invoke(target1));
		
		//增强MethodHandle
		MethodType setterMt = MethodType.methodType(void.class, String.class);
		MethodHandle setterMh = lookup.findVirtual(HandleTarget.class, "connectName", setterMt);
		MethodHandle bindedSetterMh = setterMh.bindTo(target2);
		bindedSetterMh.invoke("love CuiHuaNiu");
		System.out.println((String) getterMh.invoke(target2));
		
		//(int, int)String
		MethodType mt=MethodType.methodType(String.class, int.class, int.class);
		System.out.println(mt.toString());
		//(int, int, float)String
		mt=mt.appendParameterTypes(float.class);
		System.out.println(mt.toString());
		//(int, double, long, int, float)String
		System.out.println(mt.toString());
		mt=mt.insertParameterTypes(1,double.class, long.class);
		System.out.println(mt.toString());
		//(int, double, int, float)String
		mt=mt.dropParameterTypes(2,3);//取消下标 2-3 个参数
		System.out.println(mt.toString());
		//(int, double, String, float)String
		mt=mt.changeParameterType(2,String.class);
		System.out.println(mt.toString());
		//(int, double, String, float)void
		mt=mt.changeReturnType(void.class);
		System.out.println(mt.toString());
	}
}
/*
这个类里面有两个构造函数（一个无参，一个有参），一个private Field, 两个public实例方法，一个public static方法以及一个private实例方法。接下来我们就具体
看一下如何访问这些元素。

1.创建Lookup
使用如下代码创建一个lookup，以这种方式得到的lookup很强大，凡是调用类支持的字节码操作，它都支持。
 MethodHandles.Lookup lookup = MethodHandles.lookup();

我们还可以使用如下代码创建，但是以此种方式创建的lookup能力是受限的，其只能访问类中public的成员。
MethodHandles.Lookup publicLookup=MethodHandles.publicLookup();

2.创建MethodType
MethodType使用其(MethodType)静态方法创建:
public static MethodType methodType(Class<?> rtype, Class<?>[] ptypes)

第一个参数是方法的返回类型，第二参数是方法的入参

其有很多非常方便的重载，基本满足了一般的使用场景

3.创建MethodHandle
主要通过lookup里面的方法来寻找

3.1创建构造函数MethodHandle
public MethodHandle findConstructor(Class<?> refc, MethodType type) 

refc: 要检索的类
type: 对应的构造函数的MethodType

3.2创建实例方法MethodHandle
 public MethodHandle findVirtual(Class<?> refc, String name, MethodType type)

name: 方法名称

3.3创建类方法的MethodHandle
public   MethodHandle findStatic(Class<?> refc, String name, MethodType type)

3.4创建非private的Field的访问MethodHandle 。
注意这个不是获取field的javabean Setter方法，与其毫无关系。通过这个setter 方法句柄我们就可以访问到这个属性了。

public MethodHandle findGetter(Class<?> refc, String name, Class<?> type)

对应的如果要设置此属性的值，使用Setter方法句柄

public MethodHandle findSetter(Class<?> refc, String name, Class<?> type)

4.调用MethodHandle
使用MethodHandle的invoke家族方法

public final native @PolymorphicSignature Object invoke(Object... args) throws Throwable;
public final native @PolymorphicSignature Object invokeExact(Object... args) throws Throwable;
...

●实际使用
首先创建一个lookup

MethodHandles.Lookup lookup = MethodHandles.lookup();

●访问构造函数
◾无参数构造器
MethodType con1Mt = MethodType.methodType(void.class);//返回类型：void,输入参数：无
MethodHandle con1Mh = lookup.findConstructor(HandleTarget.class, con1Mt);//搜索类：HandleTarget.class，无参数构造器
Object target1 = con1Mh.invoke();//获得所搜索的无参数构造器类的实例
◾有参数构造器
MethodType con2Mt = MethodType.methodType(void.class, String.class);//返回类型：void.class,输入参数：String.class
MethodHandle con2Mh = lookup.findConstructor(HandleTarget.class, con2Mt);//搜索类：HandleTarget.class，有参数(1个String参数)构造器
Object target2 = con2Mh.invoke("ErGouWang");//获得所搜索的有参数构造器类的实例

●访问非private实例方法
◾调用非private实例方法
MethodType getterMt = MethodType.methodType(String.class);
MethodHandle getterMh = lookup.findVirtual(HandleTarget.class, "getName", getterMt);//获得getName方法实例
String name = (String) getterMh.invoke(target2);
System.out.println(name);

●访问private实例方法
◾访问private方法
Method learnMethod = HandleTarget.class.getDeclaredMethod("learnPrograming", String.class);
learnMethod.setAccessible(true);
MethodHandle learnProMh = lookup.unreflect(learnMethod);
learnProMh.invoke(target1, "Java");

●访问非private类方法
◾调用静态方法
MethodType decMt = MethodType.methodType(String.class, String.class);
MethodHandle decMh = lookup.findStatic(HandleTarget.class, "declaration", decMt);
String dec = (String) decMh.invoke("庄子");
System.out.println(dec);

●访问非private属性
◾访问非private属性
MethodHandle nameMh= lookup.findGetter(HandleTarget.class,"name", String.class);
System.out.println((String) nameMh.invoke(con1Mh.invoke()));


●访问private属性
◾访问private的属性，需要借助反射
Field nameField = HandleTarget.class.getDeclaredField("name");
nameField.setAccessible(true);
MethodHandle nameFromRefMh = lookup.unreflectGetter(nameField);
System.out.println((String) nameFromRefMh.invoke(target1));


●增强MethodHandle
◾增强MethodHandle
MethodType setterMt = MethodType.methodType(void.class, String.class);
MethodHandle setterMh = lookup.findVirtual(HandleTarget.class, "connectName", setterMt);
MethodHandle bindedSetterMh = setterMh.bindTo(target2);
bindedSetterMh.invoke("love CuiHuaNiu");
System.out.println((String) getterMh.invoke(target2));

当我们创建了"connectName"方法的MethodHandle，可以不立即调用而是将其绑定到某个对象上，这个对象的类型必须是HandleTarget及其子类，那么调用重新获得MethodHandle时，其会调用到新绑定对象里面的那个方法上。

总结
江湖流传着一种说法：使用MethodHandle就像是在用Java来写字节码。这种说法是有一定道理的，因为MethodHandle里的很多操作都对应着相应的字节码。总的来说，其与反射一样，离应用型程序员日常开发比较远，但是在开发框架和和工具包时却会被大量使用
*/